Secure self-contained mechanism for managing interactions between distributed computing components

ABSTRACT

Methods, computer readable media, and devices for securely managing interactions between distributed components are provided. One method may include generating a first interaction identifier based on a first component identifier and data to be shared with a second component, storing the first interaction identifier in an interaction data store of the first component, sending a request to the second component including the first component identifier, the first interaction identifier, and the data to be shared with the second component, creating a graph node in an interaction relationship data store based on the first interaction identifier, receiving a response from the second component including a second component identifier, a second interaction identifier, and response data, and adding a relationship edge in the interaction relationship data store connecting the graph node based on the first interaction identifier with a graph node based on the second interaction identifier.

TECHNICAL FIELD

One or more implementations relate to the field of distributed computingcomponents; and more specifically, to securely managing interactionsbetween such distributed components.

BACKGROUND

In a distributed system, an operation with a specific goal may spanacross multiple components. Each of these components may use differentimplementation technology and may exchange data in the request-responseparadigm (e.g., an interaction) via an application programming interface(API). Since there may be numerous such interactions between variouscomponents during an operation's lifecycle, a system may be needed thatsaves the interaction data to be retrieved later using an efficientmechanism and that persists the relationship between these interactionsefficiently.

Components involved in an operation may also need access to data duringspecific peer component interaction in order to get the point in timeview of the operation execution. A component may need a way to validatethat the data retrieved from another component has not been tampered. Acomponent may need a control mechanism to share interaction data withonly trusted peer components and a way to map the component'ssub-processes to a parent component process.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings, which are included to provide a furtherunderstanding of the disclosed subject matter, are incorporated in andconstitute a part of this specification. The drawings also illustrateimplementations of the disclosed subject matter and together with thedetailed description explain the principles of implementations of thedisclosed subject matter. No attempt is made to show structural detailsin more detail than can be necessary for a fundamental understanding ofthe disclosed subject matter and various ways in which it can bepracticed.

FIG. 1A is a block diagram illustrating a system utilizing secureself-contained mechanism for managing interactions between distributedcomponents according to some example implementations.

FIG. 1B illustrates a sample interaction identifier according to someexample implementations.

FIG. 1C illustrates a sample schema for a system wide component registryaccording to some example implementations.

FIG. 1D illustrates a sample schema for a system wide trust storeaccording to some example implementations.

FIG. 1E illustrates a sample of a component interaction flow and aninteraction graph within a system wide interaction identifierrelationship store according to some example implementations.

FIG. 2A is a flow diagram illustrating a method for use with secureself-contained mechanism for managing interactions between distributedcomponents according to some example implementations.

FIG. 2B is a flow diagram illustrating a method for use with secureself-contained mechanism for managing interactions between distributedcomponents according to some example implementations.

FIG. 2C is a flow diagram illustrating a method for use with secureself-contained mechanism for managing interactions between distributedcomponents according to some example implementations.

FIG. 3A is a block diagram illustrating an electronic device accordingto some example implementations.

FIG. 3B is a block diagram of a deployment environment according to someexample implementations.

DETAILED DESCRIPTION

Various aspects or features of this disclosure are described withreference to the drawings, wherein like reference numerals are used torefer to like elements throughout. In this specification, numerousdetails are set forth in order to provide a thorough understanding ofthis disclosure. It should be understood, however, that certain aspectsof disclosure can be practiced without these specific details, or withother methods, components, materials, or the like. In other instances,well-known structures and devices are shown in block diagram form tofacilitate describing the subject disclosure.

Various components may be involved in a distributed operation with eachcomponent performing a corresponding process. For example, a distributedoperation may be an executable process and each component may be asubprocess, such as a function or subroutine. As another example, adistributed operation may be a process, such as order fulfillment, andeach component may be a different element within the process, such asinventory check, backfill, item retrieval, item packing or the like. Asstill another example, a distributed operation may be a task to beperformed in parallel or otherwise utilizing threading technology andeach component may represent a parallel path or individual thread. Assuch, a component may be an executable subprocess, an executableprocess, a processor, a server, a database, or the like.

As part of executing a process, a component may generate data that needsto be shared with one or more other components. The component may need away to store the generated data internally as well as securely share thegenerated data with only trusted peers. For example, component 1 maygenerate data that will only be shared with component 2 while component2 may generate data that will only be shared with component 3. Component1 may need, for example, a way to identify component 2 as a trusted peerthat has access to the generated data. In addition, component 2 mayneed, for example, a way to validate the integrity of the data receivedfrom component 1.

In various implementations, each component involved in executing anoperation that spans a distributed system may be considered as a node ina graph and each interaction between components may be considered anedge between corresponding nodes in the graph. The various componentsmay need to exchange data generated as part of the operation in a securemanner. Each component may need to identify trusted peer components and,when a component receives data, the component may need to validate theintegrity of the data (e.g., perform non-repudiation or otherwiseconfirm the data has not been altered).

In one example, component 1 may generate a unique interaction identifierbased on data generated by a process performed by component 1. Forexample, component 1 may be an inventory quantity function which maygenerate data such as a number of available units of inventory items. Inthis example, component 1 may utilize the interaction identifier tostore the generated data and may send the interaction identifier to apeer component, component 2 for example, as an identity of the data.Component 2 may, for example, retrieve the generated data from component1 using the interaction identifier. Component 2 may also, for example,validate the integrity of the process data using the interactionidentifier. Continuing the example, component 2 may be a backfillfunction that determines whether and how many additional units of aninventory item should be ordered based on the number of available unitsgenerated by component 1.

Further in this example, component 1 may determine that component 2 is atrusted peer and allowed to retrieve the data based on a system widetrust store. The system wide trust store may include, for example, alist of all authorized peer components as well as a shared secret to beshared among the authorized peer components. In this example, an entryfor component 1 in the trust store may include component 2 (but notcomponent 3) as an authorized peer and component 1's shared secret to beshared with component 2. Similarly, an entry for component 2 in thetrust store may include component 1 and component 3 as authorized peersand component 2's shared secret to be shared with components 1 and 3.For example, component 3 may be a backfill order receiving function thatgenerates a status of whether additional received units equal a numberof units ordered as a result of the backfill function of component 2 byreferencing an additional units count generated by component 2.

Continuing this example, components 1 and 2 may each create a record ofthe interaction in a system wide interaction identifier relationshipstore in order to create an immutable interaction chain for any givendistributed operation. For example, component 1 may add a directed graphedge between a graph node corresponding to component 1 and a graph nodecorresponding to component 2 (e.g., an arrow pointing from component 1'snode to component 2's node). Component 2 may also, for example, add adirected graph edge between the two component's nodes (e.g., an arrowpointing from component 2's node to component 1's node).

Additionally in this example, a component, such as component 2, may alsolink the component's sub-processes to a parent component's interactionidentifier, such as component 1's interaction identifier for thisinteraction. In this way, a parent interaction identifier may give anidentify to sub-processes that may be able to map a child component'soperation flow to the parent component's data.

Implementations of the disclosed subject matter provide methods,computer readable media, and devices for a secure self-containedmechanism for managing interactions between distributed components. Invarious implementations, a method may include generating a firstinteraction identifier by a first component, the first interactionidentifier based on a component identifier of the first component anddata to be shared with a second component, storing the first interactionidentifier in an interaction data store of the first component, sendinga request to the second component including the component identifier ofthe first component, the first interaction identifier, and the data tobe shared with the second component, creating a graph node based on thefirst interaction identifier in an interaction relationship data storeaccessible by components in the distributed system, receiving a responsefrom the second component including a component identifier of the secondcomponent, a second interaction identifier, and response data, andadding a relationship edge connecting the graph node based on the firstinteraction identifier with a graph node based on the second interactionidentifier in the interaction relationship data store.

In some implementations, the method may further include subsequentlyretrieving the response data from the second component by requesting aninteraction identifier discovery uniform resource locator (URL)corresponding to the second component from a component registry,requesting a shared secret corresponding to the second component from atrust store, requesting the response data from the second component bysubmitting the second interaction identifier via the interactionidentifier discovery URL corresponding to the second component,generating a reference interaction identifier based on the response datareceived from the second component, and comparing the referenceinteraction identifier and the second interaction identifier todetermine an integrity of the received response data.

In various implementations, generating a first interaction identifiermay include generating a keyed cryptographic hash of the data to beshared with the second component, the keyed cryptographic hash beingbased on a shared secret shared between the first and second components.

In some implementations, the method may further include registering thefirst component in a component registry by providing the componentidentifier of the first component, a component name of the firstcomponent, an interaction identifier discovery universal resourcelocation (URL) of the first component, and an interaction identifierresponse type.

In some implementations, the method may further include creating anentry corresponding to the first component in a trust store accessibleby components in the distributed system, the entry including thecomponent identifier of the first component, a shared secret, and one ormore peer component identifiers, each peer component identifier being acomponent authorized to interact with the first component.

FIG. 1A illustrates a system 100 utilizing a secure self-containedmechanism for managing interactions between distributed componentsaccording to some example implementations. In various implementations, adistributed operation 110 may include a number of components, such ascomponent 1 102 a, component 2 102 b, and component N 102 n. Eachcomponent may include an interaction data store and a process. Forexample, component 1 102 a may include interaction data store 104 a andprocess 106 a. Similarly, component 2 102 b may include interaction datastore 104 b and process 106 b while component N 102 n may includeinteraction data store 104 n and process 106 n. Although system 100 ofFIG. 1 only shows three components within a single distributedoperation, this is only for simplicity. System 100 of FIG. 1 may includea plurality of distributed operations and each component may participatein any number of distributed operations. System 100 may also include atrust store 112, a component registry 114, and an interactionrelationship store 116.

In various implementations, each component may register with componentregistry 114. As described in greater detail below in relation to FIG.1C, component registry 114 may include, for example, an entry for eachcomponent in distributed operation 110. Each entry may include, forexample, a component identifier, a component name, an interactionidentifier discovery uniform resource locator (URL), and an interactionidentifier response type.

In various implementations, trust store 112 may include, for example, anindication of which components may be authorized peer components of thevarious components within the distributed operation. As described ingreater detail below in relation to FIG. 1D, trust store 112 mayinclude, for example, an entry for each component in distributedoperation 110. For example, an entry may include a component identifierof the component for which the entry corresponds, a component secret ofthe component, and one or more component identifiers of peer componentsauthorized to interact with the component.

In various implementations, interaction relationship store 116 mayinclude, for example, a graph depicting component interaction flow aswell as an interaction graph. In some implementations, the componentinteraction flow graph may include, for example, a graph nodecorresponding to each component and graph edges corresponding to variousinteractions between the components. In some implementations, theinteraction graph may include, for example, a graph node correspondingto each interaction within the distributed operation and graph edgesproviding an indication of hierarchy/order of interactions and/or adirection of flow of an interaction.

FIG. 1B illustrates a sample interaction identifier 120 generated aspart of a secure self-contained mechanism for managing interactionsbetween distributed components according to some exampleimplementations. In particular, interaction identifier 122 may be anidentifier generated based on value 124. In various implementations,value 124 may be data to be shared with a peer component within adistributed operation. For example, component 1 may generate value 124as part of a process performed by component 1. In the example shown inFIG. 1B, value 124 may be a set of name:value pairs. However, value 124may be any value, set of values, or any representation of data generatedas a result of a process. In turn, component 1 may, for example, sharevalue 124 with component 2. In order to share value 124 with component2, component 1 may, for example, generate interaction identifier 122based on value 124. In various implementations, interaction identifier122 may be generated by utilizing an encoding algorithm with minimumcollisions. For example, a hashed-based message authentication code(HMAC) may be generated by passing value 124 through a cryptographichash function using a secret cryptographic key. In one example,interaction identifier 122 may be generated using the formulaiid_((c))=∫₁ ^(n) f(value_((n)))*secret_((c)), where c is thecorresponding component within a distributed system, n is the number ofdata points of the process that the component persists and is ready toshare, f is a robust encoding algorithm with minimum collisions such asHMAC with SHA256, and secret is a component-specific secret key used ingenerating an HMAC. In various implementations, the secret may only beshared with trusted peer components within the distributed operation.More generally, an interaction identifier may represent, for example, akeyed hash of data generated by a component and, in order to share thegenerated data, the component may share the interaction identifier withone or more trusted peer components.

FIG. 1C illustrates a sample schema 140 for a system wide componentregistry of a secure self-contained mechanism for managing interactionsbetween distributed components according to some exampleimplementations. In various implementations, each entry in a system widecomponent registry, such as component registry 114 of FIG. 1A, mayinclude a component_id field 142, a component_name field 144, aniid_discovery_url field 146, and an iid_response_type field 148.Component_id field 142 may include, for example, a unique identifierwhich identifies the component within a distributed namespace.Component_name field 144 may include, for example, a name of thecorresponding component. Iid_discovery_url field 146 may include, forexample, a namespace URL which can be used to lookup data using aninteraction identifier, such as interaction identifier 122 of FIG. 1B.In some implementations, each component provides their own correspondingiid_discovery_url which, when accessed by a peer component, returns alldata in javascript object notation (JSON) format. Iid_response_typefield 148 may include, for example, an object type of the correspondinginteraction identifier response payload. In various implementations, asystem wide component registry, such as component registry 114 of FIG.1A, may include an entry for each component within the distributedoperation and each entry may follow schema 140.

FIG. 1D illustrates a sample schema 160 for a system wide trust store ofa secure self-contained mechanism for managing interactions betweendistributed components according to some example implementations. Invarious implementations, each entry in a system wide trust store, suchas trust store 112 of FIG. 1A, may include a component ID field 162, acomponent secret field 164, and one or more authorized peer component IDfields 166 a . . . n. Component ID field 162 may include, for example,the component identifier of the component corresponding to the entry.Component secret field 164 may include, for example, a component secretto be shared only with trusted peer components within a distributedoperation. Authorized peer component ID fields 166 a . . . n mayinclude, for example, the component identifier of each peer componenttrusted to interact with the component corresponding to the entry. Forexample, trust store entry 172 corresponds to component 1 and truststore entry 174 corresponds to component 4. In this example, component 1may have component 3, component 4, and component 5 as authorized peerswhile component 4 may have component 5, component 3, and component 8 asauthorized peers. Of note, while component 4 may be an authorized peerof component 1, component 1 may not be an authorized peer of component4. As such, component 1 may share data generated by component 1 withcomponent 4, but component 4 may not share data generated by component 4with component 1. More generally, each entry in a system wide truststore, such as trust store 112 of FIG. 1A, may represent one or moreunidirectional interactions from the component ID included in componentID field 162 to the authorized peer component IDs included in authorizedpeer component ID fields 166 a . . . n and the one or moreunidirectional interactions may utilize the shared secret included incomponent secret field 164.

FIG. 1E illustrates a sample of a component interaction flow 180 and aninteraction graph 190 within a system wide interaction identifierrelationship store of a secure self-contained mechanism for managinginteractions between distributed components according to some exampleimplementations. In various implementations, component interaction flow180 may include, for example, each component within a distributed systemrepresented as a node and unidirectional interactions between componentsrepresented as edges connecting corresponding nodes. For example,component 1 181, component 2 182, component 3 183, and component 7 184may participate in a particular distributed operation, such as thosepreviously disclosed herein. In various implementations, interactiongraph 190 may include, for example, each unidirectional interactionrepresented as a node and relationships represented as edges connectingcorresponding nodes. For example, interaction identifier nodes 191, 192,193, 194, 195 corresponding to interaction identifiers IiD_1-2, IiD_2-1,IiD_2-3, IiD_3-2, and IiD_3-7 may be represented as nodes with thevarious edges representing relationships between the interactions, suchas those previously disclosed.

In one example, component 1 181 may share data with component 2 182,component 2 182 may share data with component 3 183, and component 3 183may share data with component 7 184. In order to share data withcomponent 2 182, component 1 181 may generate interaction identifierIiD_1-2 based on the data to be shared and send interaction identifierIiD_1-2 to component 2 182. Component 1 181 may also create aninteraction identifier node 191 corresponding to interaction identifierIiD_1-2 within the interaction graph 190. Component 2 182 may respond tocomponent 1 181 by generating interaction identifier IiD_2-1 192 basedon response data and sending interaction identifier IiD_2-1 192 tocomponent 1 181. Component 2 may also create an interaction identifiernode 192 corresponding to interaction identifier IiD_2-1 within theinteraction graph 190 as well as create an edge from interactionidentifier node 192 to interaction identifier node 191 with an edge typeof tail-of indicating that component 2 responded to component 1 withinteraction identifier IiD_2-1. After receiving the response fromcomponent 2, component 1 may create an edge from interaction identifiernode 191 to interaction identifier node 192 with an edge type of head-ofindicating that component 1 initiated the interaction.

Further in this one example, component 2 182 and component 3 183 maysimilarly exchange data and document the data exchange in the componentinteraction flow 180 and the interaction graph 190. For example,component 2 182 may generate interaction identifier IiD_2-3 based ondata generated by component 2 182 and share interaction identifierIiD_2-3 with component 3 183. Component 2 182 may also create aninteraction identifier node 193 in the interaction graph 190. Inresponse to receiving interaction identifier IiD_2-3 from component 2182, component 3 183 may generate interaction identifier IiD_3-2 basedon response data and send interaction identifier IiD_3-2 to component 2182. Component 3 183 may also create an interaction identifier node 194and an edge from interaction identifier node 194 to interactionidentifier node 193 with an edge type of tail-of. When component 2 182receives interaction identifier IiD_3-2, component 2 182 may create anedge from interaction identifier node 193 to interaction identifier node194 with an edge type of head-of. In this way, the system wideinteraction identifier relationship store, such as interactionidentifier relationship store 116 of FIG. 1A, may document the flow ofinteractions between the various components of a distributed operation(e.g., component interaction flow 180) as well as relationships betweeninteraction identifiers within the distributed operation (e.g.,interaction graph 190).

FIG. 2A illustrates a method 200 for use in a secure self-containedmechanism for managing interactions between distributed components, asdisclosed herein. The method 200 may be performed, for example, by adistributed system and/or components within a distributed system, suchas components 102 a . . . n in FIG. 1A. In various implementations, thesteps of method 200 may be performed by a server, such as electronicdevice 300 of FIG. 3A or system 340 of FIG. 3B, and/or by softwareexecuting on a server or distributed computing platform. Although thesteps of method 200 are presented in a particular order, this is onlyfor simplicity.

In step 202, a component may be registered in a component registry, suchas component registry 114 of FIG. 1A. For example, a component ID, acomponent name, an interaction identifier discovery URL, and aninteraction identifier response type corresponding to the component maybe registered in the component registry. In various implementations,step 202 may be repetitively performed for each component within adistributed system.

In step 204, an entry for a component may be created in a trust store,such as trust store 112 of FIG. 1A. For example, an entry including acomponent ID and a component secret corresponding to the component aswell as component IDs of peer components authorized to interact with thecomponent may be created in the trust store. In various implementations,step 204 may be repetitively performed for each component within adistributed system.

In step 206, a component may generate a first interaction identifier. Invarious implementations, the first interaction identifier may be basedon data generated by the component to be shared with one or more peercomponents. In some implementations, the first interaction identifiermay be a keyed hash of the data to be shared. For example, the componentmay generate the first interaction identifier by performing a hash ofthe data to be shared with a secret key.

In step 208, a component may store the first interaction identifier inan interaction data store of the component. For example, component 1 102a of FIG. 1A may store an interaction identifier in interaction datastore 104 a. Of note, as described above in relation to FIG. 1B, theinteraction identifier may be stored in conjunction with the generateddata used to create the interaction identifier.

In step 210, a component may send the first interaction identifier to asecond component. For example, the component may send the interactionidentifier to a peer component authorized to interact with thecomponent.

In step 212, a component may create a graph node in an interactionrelationship data store, such as interaction relationship data store 116of FIG. 1A. In various implementations, a component may create a nodecorresponding to the component in a component interaction flow, such ascomponent interaction flow 180 of FIG. 1E, as well as a nodecorresponding to the first interaction identifier in an interactiongraph, such as interaction graph 190 of FIG. 1E.

In step 214, a component may receive a second interaction identifierfrom a second component. For example, the component may receive thesecond interaction identifier from the second component in response tosending the first interaction identifier to the second component. Invarious implementations, the second interaction identifier may be basedon response data to be shared with the component by the secondcomponent. In some implementations, the second interaction identifiermay be a keyed hash of the response data. For example, the secondinteraction identifier may be created by performing a hash of theresponse data with a secret key.

In step 216, a component may add a relationship edge in an interactionrelationship data store, such as interaction relationship data store 116of FIG. 1A. In various implementations, a component may add an edgecorresponding to the first interaction identifier in a componentinteraction flow, such as component interaction flow 180 of FIG. 1E, aswell as an edge indicating a relationship type in an interaction graph,such as interaction graph 190 of FIG. 1E. For example, the component mayadd the edge corresponding to the first interaction identifier in thecomponent interaction flow between a node corresponding to the componentand a node corresponding to the second component. Similarly, thecomponent, for example, may add the edge indicating a relationship typein the interaction graph between a node corresponding to the firstinteraction identifier and a node corresponding to the secondinteraction identifier.

In step 218, a component may subsequently retrieve response datacorresponding to the second interaction identifier from the secondcomponent. For example, the component may submit the second interactionidentifier to an interaction identifier discovery URL of the secondcomponent and may receive the response data as a result of thesubmission.

FIG. 2B illustrates a method 240 for use with a secure self-containedmechanism for managing interactions between distributed components, asdisclosed herein. The method 240 may be performed, for example, by adistributed system and/or components within a distributed system, suchas components 102 a . . . n in FIG. 1A. In various implementations, thesteps of method 200 may be performed by a server, such as electronicdevice 300 of FIG. 3A or system 340 of FIG. 3B, and/or by softwareexecuting on a server or distributed computing platform. Although thesteps of method 240 are presented in a particular order, this is onlyfor simplicity. In various implementations, the method 240 may beperformed as part of registering a component with a component registry,such as in step 202 of method 200 in FIG. 2A.

In determination step 242, a determination of whether a component waspreviously registered may be made.

If a component was previously registered (i.e., determination step242=“Yes”), an indication that the component was previously registeredis sent in step 244. For example, if a component was previouslyregistered, the component may be informed of the previous registration.

If a component was not previously registered (i.e., determination step242=“No”), the method may proceed to determination step 246. Indetermination step 246, a determination of whether required attributeswere provided may be made.

If required attributes were not provided (i.e., determination step246=“No”), an indication of missing attributes may be provided in step248. For example, if a component does not provide required attributes,the component may be informed of which required attributes were notprovided.

If required attributes were provided (i.e., determination step246=“Yes”), an entry corresponding to the component may be created instep 250. For example, an entry corresponding to a component may becreated in a component registry, such as component registry 114 of FIG.1A.

FIG. 2C illustrates a method 260 for use with a secure self-containedmechanism for managing interactions between distributed components, asdisclosed herein. The method 260 may be performed, for example, by adistributed system and/or components within a distributed system, suchas components 102 a . . . n in FIG. 1A. In various implementations, thesteps of method 200 may be performed by a server, such as electronicdevice 300 of FIG. 3A or system 340 of FIG. 3B, and/or by softwareexecuting on a server or distributed computing platform. Although thesteps of method 260 are presented in a particular order, this is onlyfor simplicity. In various implementations, the method 260 may beperformed as part of subsequently retrieving response data, such as instep 218 of method 200 in FIG. 2A.

In step 262, a component may request an interaction identifier discoveryURL from a component registry, such as component registry 114 of FIG.1A. For example, a component may submit a component identifier of a peercomponent to the component registry and the component registry mayrespond with the interaction identifier discovery URL corresponding tothe peer component.

In determination step 264, a determination of whether a component is anauthorized peer component is made. For example, a trust store, such astrust store 112, may be referenced to determine whether an entry for apeer component (i.e., component ID field contains identifier of peercomponent) includes an authorized peer component field containing acomponent identifier of the component.

If the component is not an authorized peer component (i.e.,determination step 264=“No”), then the component is denied access instep 266.

If the component is an authorized peer component (i.e., determinationstep 264=“Yes”), then the method proceeds to step 268.

In step 268, a component may request a shared secret from a trust store,such as trust store 112 of FIG. 1A. For example, the component maysubmit a component identifier of a peer component to the trust store andthe trust store may respond with the shared secret corresponding to thepeer component.

In step 270, a component may request response data from a peer componentbased on an interaction identifier. In various implementations, thecomponent may have previously received the interaction identifier fromthe peer component (e.g., second interaction identifier received as partof step 214 of method 200). In various implementations, the componentmay request response data by submitting the interaction identifier tothe peer component via the interaction identifier discovery URLcorresponding to the peer component (i.e., interaction identifierdiscovery URL requested as part of step 262) and the peer component mayprovide the response data in response to the submission.

In step 272, a component may generate a reference interaction identifierbased on response data. For example, the component may generate thereference interaction identifier based on the response data receivedfrom the peer component. In various implementations, the referenceinteraction identifier may be generated by performing a keyed hash ofthe response data using the shared secret corresponding to the peercomponent.

In determination step 274, a determination of whether the referenceinteraction identifier matches the previously received interactionidentifier is made. In one example, a component may have previouslyreceived the interaction identifier from the peer component (e.g.,second interaction identifier received as part of step 214 of method200). In this example, the component may compare the received secondinteraction identifier with the reference interaction identifier todetermine if they match.

If the reference interaction identifier and previously receivedinteraction identifier do not match (i.e., determination step 274=“No”),then the response data is discarded in step 276. In variousimplementations, if the reference interaction identifier and previouslyreceived interaction identifier do not match, then the subsequentlyreceived response data may have been tampered with or otherwise may notbe valid.

If the reference interaction identifier and previously receivedinteraction identifier do match (i.e., determination step 274=“Yes”),then the component may trust the response data in step 278. In variousimplementations, if the reference interaction identifier and previouslyreceived interaction identifier do match, then the subsequently receivedresponse data may be valid or otherwise not tampered with or altered.

One or more parts of the above implementations may include software.Software is a general term whose meaning can range from part of the codeand/or metadata of a single computer program to the entirety of multipleprograms. A computer program (also referred to as a program) comprisescode and optionally data. Code (sometimes referred to as computerprogram code or program code) comprises software instructions (alsoreferred to as instructions). Instructions may be executed by hardwareto perform operations. Executing software includes executing code, whichincludes executing instructions. The execution of a program to perform atask involves executing some or all of the instructions in that program.

An electronic device (also referred to as a device, computing device,computer, etc.) includes hardware and software. For example, anelectronic device may include a set of one or more processors coupled toone or more machine-readable storage media (e.g., non-volatile memorysuch as magnetic disks, optical disks, read only memory (ROM), Flashmemory, phase change memory, solid state drives (SSDs)) to store codeand optionally data. For instance, an electronic device may includenon-volatile memory (with slower read/write times) and volatile memory(e.g., dynamic random-access memory (DRAM), static random-access memory(SRAM)). Non-volatile memory persists code/data even when the electronicdevice is turned off or when power is otherwise removed, and theelectronic device copies that part of the code that is to be executed bythe set of processors of that electronic device from the non-volatilememory into the volatile memory of that electronic device duringoperation because volatile memory typically has faster read/write times.As another example, an electronic device may include a non-volatilememory (e.g., phase change memory) that persists code/data when theelectronic device has power removed, and that has sufficiently fastread/write times such that, rather than copying the part of the code tobe executed into volatile memory, the code/data may be provided directlyto the set of processors (e.g., loaded into a cache of the set ofprocessors). In other words, this non-volatile memory operates as bothlong term storage and main memory, and thus the electronic device mayhave no or only a small amount of volatile memory for main memory.

In addition to storing code and/or data on machine-readable storagemedia, typical electronic devices can transmit and/or receive codeand/or data over one or more machine-readable transmission media (alsocalled a carrier) (e.g., electrical, optical, radio, acoustical or otherforms of propagated signals—such as carrier waves, and/or infraredsignals). For instance, typical electronic devices also include a set ofone or more physical network interface(s) to establish networkconnections (to transmit and/or receive code and/or data usingpropagated signals) with other electronic devices. Thus, an electronicdevice may store and transmit (internally and/or with other electronicdevices over a network) code and/or data with one or moremachine-readable media (also referred to as computer-readable media).

Software instructions (also referred to as instructions) are capable ofcausing (also referred to as operable to cause and configurable tocause) a set of processors to perform operations when the instructionsare executed by the set of processors. The phrase “capable of causing”(and synonyms mentioned above) includes various scenarios (orcombinations thereof), such as instructions that are always executedversus instructions that may be executed. For example, instructions maybe executed: 1) only in certain situations when the larger program isexecuted (e.g., a condition is fulfilled in the larger program; an eventoccurs such as a software or hardware interrupt, user input (e.g., akeystroke, a mouse-click, a voice command); a message is published,etc.); or 2) when the instructions are called by another program or partthereof (whether or not executed in the same or a different process,thread, lightweight thread, etc.). These scenarios may or may notrequire that a larger program, of which the instructions are a part, becurrently configured to use those instructions (e.g., may or may notrequire that a user enables a feature, the feature or instructions beunlocked or enabled, the larger program is configured using data and theprogram's inherent functionality, etc.). As shown by these exemplaryscenarios, “capable of causing” (and synonyms mentioned above) does notrequire “causing” but the mere capability to cause. While the term“instructions” may be used to refer to the instructions that whenexecuted cause the performance of the operations described herein, theterm may or may not also refer to other instructions that a program mayinclude. Thus, instructions, code, program, and software are capable ofcausing operations when executed, whether the operations are alwaysperformed or sometimes performed (e.g., in the scenarios describedpreviously). The phrase “the instructions when executed” refers to atleast the instructions that when executed cause the performance of theoperations described herein but may or may not refer to the execution ofthe other instructions.

Electronic devices are designed for and/or used for a variety ofpurposes, and different terms may reflect those purposes (e.g., userdevices, network devices). Some user devices are designed to mainly beoperated as servers (sometimes referred to as server devices), whileothers are designed to mainly be operated as clients (sometimes referredto as client devices, client computing devices, client computers, or enduser devices; examples of which include desktops, workstations, laptops,personal digital assistants, smartphones, wearables, augmented reality(AR) devices, virtual reality (VR) devices, mixed reality (MR) devices,etc.). The software executed to operate a user device (typically aserver device) as a server may be referred to as server software orserver code), while the software executed to operate a user device(typically a client device) as a client may be referred to as clientsoftware or client code. A server provides one or more services (alsoreferred to as serves) to one or more clients.

The term “user” refers to an entity (e.g., an individual person) thatuses an electronic device. Software and/or services may use credentialsto distinguish different accounts associated with the same and/ordifferent users. Users can have one or more roles, such asadministrator, programmer/developer, and end user roles. As anadministrator, a user typically uses electronic devices to administerthem for other users, and thus an administrator often works directlyand/or indirectly with server devices and client devices.

FIG. 3A is a block diagram illustrating an electronic device 300according to some example implementations. FIG. 3A includes hardware 320comprising a set of one or more processor(s) 322, a set of one or morenetwork interfaces 324 (wireless and/or wired), and machine-readablemedia 326 having stored therein software 328 (which includesinstructions executable by the set of one or more processor(s) 322). Themachine-readable media 326 may include non-transitory and/or transitorymachine-readable media. Each of the previously described clients andsecure self-contained mechanism for managing interactions betweendistributed components may be implemented in one or more electronicdevices 300.

During operation, an instance of the software 328 (illustrated asinstance 306 and referred to as a software instance; and in the morespecific case of an application, as an application instance) isexecuted. In electronic devices that use compute virtualization, the setof one or more processor(s) 322 typically execute software toinstantiate a virtualization layer 308 and one or more softwarecontainer(s) 304A-304R (e.g., with operating system-levelvirtualization, the virtualization layer 308 may represent a containerengine running on top of (or integrated into) an operating system, andit allows for the creation of multiple software containers 304A-304R(representing separate user space instances and also calledvirtualization engines, virtual private servers, or jails) that may eachbe used to execute a set of one or more applications; with fullvirtualization, the virtualization layer 308 represents a hypervisor(sometimes referred to as a virtual machine monitor (VMM)) or ahypervisor executing on top of a host operating system, and the softwarecontainers 304A-304R each represent a tightly isolated form of asoftware container called a virtual machine that is run by thehypervisor and may include a guest operating system; withpara-virtualization, an operating system and/or application running witha virtual machine may be aware of the presence of virtualization foroptimization purposes). Again, in electronic devices where computevirtualization is used, during operation, an instance of the software328 is executed within the software container 304A on the virtualizationlayer 308. In electronic devices where compute virtualization is notused, the instance 306 on top of a host operating system is executed onthe “bare metal” electronic device 300. The instantiation of theinstance 306, as well as the virtualization layer 308 and softwarecontainers 304A-304R if implemented, are collectively referred to assoftware instance(s) 302.

Alternative implementations of an electronic device may have numerousvariations from that described above. For example, customized hardwareand/or accelerators might also be used in an electronic device.

FIG. 3B is a block diagram of a deployment environment according to someexample implementations. A system 340 includes hardware (e.g., a set ofone or more server devices) and software to provide service(s) 342,including a secure self-contained mechanism for managing interactionsbetween distributed components. In some implementations the system 340is in one or more datacenter(s). These datacenter(s) may be: 1) firstparty datacenter(s), which are datacenter(s) owned and/or operated bythe same entity that provides and/or operates some or all of thesoftware that provides the service(s) 342; and/or 2) third-partydatacenter(s), which are datacenter(s) owned and/or operated by one ormore different entities than the entity that provides the service(s) 342(e.g., the different entities may host some or all of the softwareprovided and/or operated by the entity that provides the service(s)342). For example, third-party datacenters may be owned and/or operatedby entities providing public cloud services.

The system 340 is coupled to user devices 380A-380S over a network 382.The service(s) 342 may be on-demand services that are made available toone or more of the users 384A-384S working for one or more entitiesother than the entity which owns and/or operates the on-demand services(those users sometimes referred to as outside users) so that thoseentities need not be concerned with building and/or maintaining asystem, but instead may make use of the service(s) 342 when needed(e.g., when needed by the users 384A-384S). The service(s) 342 maycommunicate with each other and/or with one or more of the user devices380A-380S via one or more APIs (e.g., a REST API). In someimplementations, the user devices 380A-380S are operated by users384A-384S, and each may be operated as a client device and/or a serverdevice. In some implementations, one or more of the user devices380A-380S are separate ones of the electronic device 300 or include oneor more features of the electronic device 300.

In some implementations, the system 340 is a multi-tenant system (alsoknown as a multi-tenant architecture). The term multi-tenant systemrefers to a system in which various elements of hardware and/or softwareof the system may be shared by one or more tenants. A multi-tenantsystem may be operated by a first entity (sometimes referred to amulti-tenant system provider, operator, or vendor; or simply a provider,operator, or vendor) that provides one or more services to the tenants(in which case the tenants are customers of the operator and sometimesreferred to as operator customers). A tenant includes a group of userswho share a common access with specific privileges. The tenants may bedifferent entities (e.g., different companies, differentdepartments/divisions of a company, and/or other types of entities), andsome or all of these entities may be vendors that sell or otherwiseprovide products and/or services to their customers (sometimes referredto as tenant customers). A multi-tenant system may allow each tenant toinput tenant specific data for user management, tenant-specificfunctionality, configuration, customizations, non-functional properties,associated applications, etc. A tenant may have one or more rolesrelative to a system and/or service. For example, in the context of acustomer relationship management (CRM) system or service, a tenant maybe a vendor using the CRM system or service to manage information thetenant has regarding one or more customers of the vendor. As anotherexample, in the context of Data as a Service (DAAS), one set of tenantsmay be vendors providing data and another set of tenants may becustomers of different ones or all of the vendors' data. As anotherexample, in the context of Platform as a Service (PAAS), one set oftenants may be third-party application developers providingapplications/services and another set of tenants may be customers ofdifferent ones or all of the third-party application developers.

Multi-tenancy can be implemented in different ways. In someimplementations, a multi-tenant architecture may include a singlesoftware instance (e.g., a single database instance) which is shared bymultiple tenants; other implementations may include a single softwareinstance (e.g., database instance) per tenant; yet other implementationsmay include a mixed model; e.g., a single software instance (e.g., anapplication instance) per tenant and another software instance (e.g.,database instance) shared by multiple tenants.

In one implementation, the system 340 is a multi-tenant cloud computingarchitecture supporting multiple services, such as one or more of thefollowing types of services: Customer relationship management (CRM);Configure, price, quote (CPQ); Business process modeling (BPM); Customersupport; Marketing; Productivity; Database-as-a-Service;Data-as-a-Service (DAAS or DaaS); Platform-as-a-service (PAAS or PaaS);Infrastructure-as-a-Service (IAAS or IaaS) (e.g., virtual machines,servers, and/or storage); Analytics; Community; Internet-of-Things(IoT); Industry-specific; Artificial intelligence (AI); Applicationmarketplace (“app store”); Data modeling; Security; and Identity andaccess management (IAM). For example, system 340 may include anapplication platform 344 that enables PAAS for creating, managing, andexecuting one or more applications developed by the provider of theapplication platform 344, users accessing the system 340 via one or moreof user devices 380A-380S, or third-party application developersaccessing the system 340 via one or more of user devices 380A-380S.

In some implementations, one or more of the service(s) 342 may use oneor more multi-tenant databases 346, as well as system data storage 350for system data 352 accessible to system 340. In certainimplementations, the system 340 includes a set of one or more serversthat are running on server electronic devices and that are configured tohandle requests for any authorized user associated with any tenant(there is no server affinity for a user and/or tenant to a specificserver). The user devices 380A-380S communicate with the server(s) ofsystem 340 to request and update tenant-level data and system-level datahosted by system 340, and in response the system 340 (e.g., one or moreservers in system 340) automatically may generate one or more StructuredQuery Language (SQL) statements (e.g., one or more SQL queries) that aredesigned to access the desired information from the multi-tenantdatabase(s) 346 and/or system data storage 350.

In some implementations, the service(s) 342 are implemented usingvirtual applications dynamically created at run time responsive toqueries from the user devices 380A-380S and in accordance with metadata,including: 1) metadata that describes constructs (e.g., forms, reports,workflows, user access privileges, business logic) that are common tomultiple tenants; and/or 2) metadata that is tenant specific anddescribes tenant specific constructs (e.g., tables, reports, dashboards,interfaces, etc.) and is stored in a multi-tenant database. To that end,the program code 360 may be a runtime engine that materializesapplication data from the metadata; that is, there is a clear separationof the compiled runtime engine (also known as the system kernel), tenantdata, and the metadata, which makes it possible to independently updatethe system kernel and tenant-specific applications and schemas, withvirtually no risk of one affecting the others. Further, in oneimplementation, the application platform 344 includes an applicationsetup mechanism that supports application developers' creation andmanagement of applications, which may be saved as metadata by saveroutines. Invocations to such applications, including the framework formodeling heterogeneous feature sets, may be coded using ProceduralLanguage/Structured Object Query Language (PL/SOQL) that provides aprogramming language style interface. Invocations to applications may bedetected by one or more system processes, which manages retrievingapplication metadata for the tenant making the invocation and executingthe metadata as an application in a software container (e.g., a virtualmachine).

Network 382 may be any one or any combination of a LAN (local areanetwork), WAN (wide area network), telephone network, wireless network,point-to-point network, star network, token ring network, hub network,or other appropriate configuration. The network may comply with one ormore network protocols, including an Institute of Electrical andElectronics Engineers (IEEE) protocol, a 3rd Generation PartnershipProject (3GPP) protocol, a 4^(th) generation wireless protocol (4G)(e.g., the Long Term Evolution (LTE) standard, LTE Advanced, LTEAdvanced Pro), a fifth generation wireless protocol (5G), and/or similarwired and/or wireless protocols, and may include one or moreintermediary devices for routing data between the system 340 and theuser devices 380A-380S.

Each user device 380A-380S (such as a desktop personal computer,workstation, laptop, Personal Digital Assistant (PDA), smartphone,smartwatch, wearable device, augmented reality (AR) device, virtualreality (VR) device, etc.) typically includes one or more user interfacedevices, such as a keyboard, a mouse, a trackball, a touch pad, a touchscreen, a pen or the like, video or touch free user interfaces, forinteracting with a graphical user interface (GUI) provided on a display(e.g., a monitor screen, a liquid crystal display (LCD), a head-updisplay, a head-mounted display, etc.) in conjunction with pages, forms,applications and other information provided by system 340. For example,the user interface device can be used to access data and applicationshosted by system 340, and to perform searches on stored data, andotherwise allow one or more of users 384A-384S to interact with variousGUI pages that may be presented to the one or more of users 384A-384S.User devices 380A-380S might communicate with system 340 using TCP/IP(Transfer Control Protocol and Internet Protocol) and, at a highernetwork level, use other networking protocols to communicate, such asHypertext Transfer Protocol (HTTP), File Transfer Protocol (FTP), AndrewFile System (AFS), Wireless Application Protocol (WAP), Network FileSystem (NFS), an application program interface (API) based uponprotocols such as Simple Object Access Protocol (SOAP), RepresentationalState Transfer (REST), etc. In an example where HTTP is used, one ormore user devices 380A-380S might include an HTTP client, commonlyreferred to as a “browser,” for sending and receiving HTTP messages toand from server(s) of system 340, thus allowing users 384A-384S of theuser devices 380A-380S to access, process and view information, pagesand applications available to it from system 340 over network 382.

In the above description, numerous specific details such as resourcepartitioning/sharing/duplication implementations, types andinterrelationships of system components, and logicpartitioning/integration choices are set forth in order to provide amore thorough understanding. The invention may be practiced without suchspecific details, however. In other instances, control structures, logicimplementations, opcodes, means to specify operands, and full softwareinstruction sequences have not been shown in detail since those ofordinary skill in the art, with the included descriptions, will be ableto implement what is described without undue experimentation.

References in the specification to “one implementation,” “animplementation,” “an example implementation,” etc., indicate that theimplementation described may include a particular feature, structure, orcharacteristic, but every implementation may not necessarily include theparticular feature, structure, or characteristic. Moreover, such phrasesare not necessarily referring to the same implementation. Further, whena particular feature, structure, and/or characteristic is described inconnection with an implementation, one skilled in the art would know toaffect such feature, structure, and/or characteristic in connection withother implementations whether or not explicitly described.

For example, the figure(s) illustrating flow diagrams sometimes refer tothe figure(s) illustrating block diagrams, and vice versa. Whether ornot explicitly described, the alternative implementations discussed withreference to the figure(s) illustrating block diagrams also apply to theimplementations discussed with reference to the figure(s) illustratingflow diagrams, and vice versa. At the same time, the scope of thisdescription includes implementations, other than those discussed withreference to the block diagrams, for performing the flow diagrams, andvice versa.

Bracketed text and blocks with dashed borders (e.g., large dashes, smalldashes, dot-dash, and dots) may be used herein to illustrate optionaloperations and/or structures that add additional features to someimplementations. However, such notation should not be taken to mean thatthese are the only options or optional operations, and/or that blockswith solid borders are not optional in certain implementations.

The detailed description and claims may use the term “coupled,” alongwith its derivatives. “Coupled” is used to indicate that two or moreelements, which may or may not be in direct physical or electricalcontact with each other, co-operate or interact with each other.

While the flow diagrams in the figures show a particular order ofoperations performed by certain implementations, such order is exemplaryand not limiting (e.g., alternative implementations may perform theoperations in a different order, combine certain operations, performcertain operations in parallel, overlap performance of certainoperations such that they are partially in parallel, etc.).

While the above description includes several example implementations,the invention is not limited to the implementations described and can bepracticed with modification and alteration within the spirit and scopeof the appended claims. The description is thus illustrative instead oflimiting.

What is claimed is:
 1. A computer-implemented method comprising:generating, by a first component in a distributed system, a firstinteraction identifier based on: a component identifier of the firstcomponent; and data to be shared with a second component; storing thefirst interaction identifier in an interaction data store of the firstcomponent; sending a request to the second component, the requestincluding the component identifier of the first component, the firstinteraction identifier, and the data to be shared with the secondcomponent; creating a graph node in an interaction relationship datastore based on the first interaction identifier, the interactionrelationship data store being accessible by components in thedistributed system; receiving a response from the second component, theresponse including a component identifier of the second component, asecond interaction identifier, and response data; and adding arelationship edge in the interaction relationship data store, therelationship edge connecting the graph node based on the firstinteraction identifier with a graph node based on the second interactionidentifier.
 2. The computer-implemented method of claim 1, furthercomprising subsequently retrieving the response data from the secondcomponent by: requesting an interaction identifier discovery uniformresource locator (URL) corresponding to the second component from acomponent registry; requesting a shared secret corresponding to thesecond component from a trust store; requesting the response data fromthe second component by submitting the second interaction identifier viathe interaction identifier discovery URL corresponding to the secondcomponent; generating a reference interaction identifier based on theresponse data received from the second component; and comparing thereference interaction identifier and the second interaction identifierto determine an integrity of the received response data.
 3. Thecomputer-implemented method of claim 1, wherein generating a firstinteraction identifier comprises generating a keyed cryptographic hashof the data to be shared with the second component, the keyedcryptographic hash being based on a shared secret shared between thefirst and second components.
 4. The computer-implemented method of claim1, further comprising registering the first component in a componentregistry by providing the component identifier of the first component, acomponent name of the first component, an interaction identifierdiscovery universal resource location (URL) of the first component, andan interaction identifier response type.
 5. The computer-implementedmethod of claim 1, further comprising creating an entry corresponding tothe first component in a trust store accessible by components in thedistributed system, the entry including the component identifier of thefirst component, a shared secret, and one or more peer componentidentifiers, each peer component identifier being a component authorizedto interact with the first component.
 6. A non-transitorymachine-readable storage medium that provides instructions that, ifexecuted by a processor, are configurable to cause the processor toperform operations comprising: generating, by a first component in adistributed system, a first interaction identifier based on: a componentidentifier of the first component; and data to be shared with a secondcomponent; storing the first interaction identifier in an interactiondata store of the first component; sending a request to the secondcomponent, the request including the component identifier of the firstcomponent, the first interaction identifier, and the data to be sharedwith the second component; creating a graph node in an interactionrelationship data store based on the first interaction identifier, theinteraction relationship data store being accessible by components inthe distributed system; receiving a response from the second component,the response including a component identifier of the second component, asecond interaction identifier, and response data; and adding arelationship edge in the interaction relationship data store, therelationship edge connecting the graph node based on the firstinteraction identifier with a graph node based on the second interactionidentifier.
 7. The non-transitory machine-readable storage medium ofclaim 6, wherein the instructions are further configurable to cause theprocessor to perform further operations comprising subsequentlyretrieving the response data from the second component by: requesting aninteraction identifier discovery uniform resource locator (URL)corresponding to the second component from a component registry;requesting a shared secret corresponding to the second component from atrust store; requesting the response data from the second component bysubmitting the second interaction identifier via the interactionidentifier discovery URL corresponding to the second component;generating a reference interaction identifier based on the response datareceived from the second component; and comparing the referenceinteraction identifier and the second interaction identifier todetermine an integrity of the received response data.
 8. Thenon-transitory machine-readable storage medium of claim 6, whereingenerating a first interaction identifier comprises generating a keyedcryptographic hash of the data to be shared with the second component,the keyed cryptographic hash being based on a shared secret sharedbetween the first and second components.
 9. The non-transitorymachine-readable storage medium of claim 6, wherein the instructions arefurther configurable to cause the processor to perform furtheroperations comprising registering the first component in a componentregistry by providing the component identifier of the first component, acomponent name of the first component, an interaction identifierdiscovery universal resource location (URL) of the first component, andan interaction identifier response type.
 10. The non-transitorymachine-readable storage medium of claim 6, wherein the instructions arefurther configurable to cause the processor to perform furtheroperations comprising creating an entry corresponding to the firstcomponent in a trust store accessible by components in the distributedsystem, the entry including the component identifier of the firstcomponent, a shared secret, and one or more peer component identifiers,each peer component identifier being a component authorized to interactwith the first component.
 11. An apparatus comprising: a processor; anda non-transitory machine-readable storage medium that providesinstructions that, if executed by the processor, are configurable tocause the apparatus to perform operations comprising: generating, by afirst component in a distributed system, a first interaction identifierbased on: a component identifier of the first component; and data to beshared with a second component; storing the first interaction identifierin an interaction data store of the first component; sending a requestto the second component, the request including the component identifierof the first component, the first interaction identifier, and the datato be shared with the second component; creating a graph node in aninteraction relationship data store based on the first interactionidentifier, the interaction relationship data store being accessible bycomponents in the distributed system; receiving a response from thesecond component, the response including a component identifier of thesecond component, a second interaction identifier, and response data;and adding a relationship edge in the interaction relationship datastore, the relationship edge connecting the graph node based on thefirst interaction identifier with a graph node based on the secondinteraction identifier.
 12. The apparatus of claim 11, wherein theinstructions are further configurable to cause the processor to performfurther operations comprising subsequently retrieving the response datafrom the second component by: requesting an interaction identifierdiscovery uniform resource locator (URL) corresponding to the secondcomponent from a component registry; requesting a shared secretcorresponding to the second component from a trust store; requesting theresponse data from the second component by submitting the secondinteraction identifier via the interaction identifier discovery URLcorresponding to the second component; generating a referenceinteraction identifier based on the response data received from thesecond component; and comparing the reference interaction identifier andthe second interaction identifier to determine an integrity of thereceived response data.
 13. The apparatus of claim 11, whereingenerating a first interaction identifier comprises generating a keyedcryptographic hash of the data to be shared with the second component,the keyed cryptographic hash being based on a shared secret sharedbetween the first and second components.
 14. The apparatus of claim 11,wherein the instructions are further configurable to cause the processorto perform further operations comprising registering the first componentin a component registry by providing the component identifier of thefirst component, a component name of the first component, an interactionidentifier discovery universal resource location (URL) of the firstcomponent, and an interaction identifier response type.
 15. Theapparatus of claim 11, wherein the instructions are further configurableto cause the processor to perform further operations comprising creatingan entry corresponding to the first component in a trust storeaccessible by components in the distributed system, the entry includingthe component identifier of the first component, a shared secret, andone or more peer component identifiers, each peer component identifierbeing a component authorized to interact with the first component.